<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> 
<html>
<head>
<title>Operators</title>
<link rel="stylesheet" href="/cfg/format.css" type="text/css">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<meta name="keywords" content="PHP, learn PHP, operators, programming, language">
<meta name="description" content="In this part of the PHP tutorial, we cover PHP operators.">
<meta name="language" content="en">
<meta name="author" content="Jan Bodnar">
<meta name="distribution" content="global">

<script type="text/javascript" src="/lib/jquery.js"></script>
<script type="text/javascript" src="/lib/common.js"></script>

</head>

<body>

<div class="container">

<div id="wide_ad" class="ltow">
<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* 160x600, August 2011 */
google_ad_slot = "2484182563";
google_ad_width = 160;
google_ad_height = 600;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>
</div>


<div class="content">

<a href="/" title="Home">Home</a>&nbsp;
<a href="..">Contents</a>


<h1>Operators</h1>

<p>
In this part of the PHP programming tutorial, we will talk about operators. 
</p>

<p>
An <code>operator</code> is a special symbol which indicates a certain 
process is carried out. Operators in programming languages are taken from mathematics. 
Programmers work with data. The operators are used to process data. 
</p>

<div class="center">
<script type="text/javascript"><!--
google_ad_client = "ca-pub-9706709751191532";
/* top_horizontal */
google_ad_slot = "3327173442";
google_ad_width = 468;
google_ad_height = 60;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>
</div>

<p>
We have several types of operators:
</p>

<ul>
<li>Arithmetic operators</li>
<li>Boolean operators</li>
<li>Relational operators</li>
<li>Bitwise operators</li>
</ul>

<p>
An operator may have one or two operands. An <code>operand</code> is one of 
the inputs (arguments) of an operator. 
Those operators that work with only one operand are called <b>unary operators</b>. 
Those who work with two operands are called binary operators. 
</p>

<p>
+ and - signs can be addition and subtraction operators as well as unary 
sign operators. It depends on the situation.
</p>

<pre class="code">
php &gt; print +2;
2
php &gt; print -2;
-2
php &gt; print 2;
2
php &gt; print 2+2;
4
php &gt; print 2-2;
0
</pre>

<p>
The plus sign can be used to indicate that we have a positive number. 
But it is mostly not used. The minus sign changes the sign of a value.  
</p>

<pre class="code">
php &gt; $a = 1;
php &gt; print -$a;
-1
php &gt; print -(-$a);
1
</pre>

<p>
Multiplication and addition operators are examples of binary operators. 
They are used with two operands.  
</p>

<pre class="code">
php &gt; print 3 * 3;
9
php &gt; print 3 + 3;
6
</pre>


<h2>The assignment operator</h2>


<p>
The assignment operator <b>=</b> assigns a value to a variable. 
A <b>variable</b> is a placeholder for a value. In PHP, a variable begins
with a $ character. In mathematics, the <b>=</b> operator has a different 
meaning. In an equation, the <b>=</b> operator is an equality operator. 
The left side of the equation is equal to the right one. 
</p>

<pre class="code">
php &gt; $x = 1;
php &gt; print $x;
1
</pre>

<p>
Here we assign a number to an $x variable. 
</p>

<pre class="code">
php &gt; $x = $x + 1;
php &gt; print $x;
2
</pre>

<p>
The previous expression does not make sense in mathematics. But it is legal in programming. 
The expression means that we
add 1 to the $x variable. The right side is equal to 2 and 2 is assigned to x. 
</p>

<pre class="code">
php &gt; 3 = $x;

Parse error: syntax error, unexpected '=' in php shell code on line 1
</pre>

<p>
This code example results in syntax error. We cannot assign a value to a literal. 
</p>

<h2>Arithmetic operators</h2>

<p>
The following is a table of arithmetic operators in PHP. 
</p>

<table>
<tr>
<th>Symbol</th><th>Name</th>
</tr>
<tr><td>+</td><td>Addition</td></tr>
<tr class="gray"><td>-</td><td>Subtraction</td></tr>
<tr><td>*</td><td>Multiplication</td></tr>
<tr class="gray"><td>/</td><td>Division</td></tr>
<tr><td>%</td><td>Modulo</td></tr>
</table>


<p>
The following example shows arithmetic operations.
</p>

<pre class="code">
&lt;?php

$a = 10;
$b = 11;
$c = 12;

$add = $a + $b +$c;
$sub = $c - $a;
$mult = $a * $b;
$div = $c / 3;


echo $add, " " , $sub, " ";
echo $mult," ",  $div, " ";
echo "\n";

?&gt;
</pre>

<p>
All these are known operators from mathematics. 
</p>

<pre>
$ php arithmetic.php 
33 2 110 4 
</pre>


<pre class="code">
php &gt; print 9 % 4;
1
</pre>

<p>
The <b>%</b> operator is called the modulo operator. It finds the remainder 
of division of one number by another. 
<code>9 % 4</code>, 9 modulo 4 is 1, because 4 goes into 9 twice with a remainder of 1. 
</p>

<h2>Concatenating strings</h2>

<p>
We use the dot . operator to concatenate strings. 
</p>


<pre class="code">
php &gt; print 'return' . 'of' . 'the' . 'king';
returnoftheking
</pre>

<p>
The dot operator makes one string from four pieces of strings. 
</p>

<pre class="code">
php &gt; print 3 . 'apples';
3apples
</pre>

<p>
We can concatenate strings with numbers with the dot operator. Internally, 
the number is converted to 
a string a the two strings are concatenated in the end. 
</p>

<pre class="code">
php &gt; print 'apples' * 3;
0
php &gt; print 'apples' - 'oranges';
0
php &gt; print 'apples' + 'oranges';
0
</pre>

<p>
Using other operators with strings does not make much sense. We get zero. 
</p>

<pre class="code">
php &gt; print (Integer) 'apple';
0
</pre>

<p>
This is because in a numerical context, a string is equal to zero. 
</p>


<h2>Boolean operators</h2>

<p>
In PHP, we have <code>and</code>, <code>or</code> 
and negation <code>!</code> boolean operators. 
With boolean operators we perform logical operations. These are often 
used with if and while keywords. 
</p>

<pre class="code">
&lt;?php

$a = (True and True);
$b = (True and False);
$c = (False and True);
$d = (False and False);

var_dump($a, $b, $c, $d);

?&gt;
</pre>

<p>
This example shows the logical and operator. The logical and operator 
evaluates to True only if both operands are True.
</p>

<pre>
$ php andop.php 
bool(true)
bool(false)
bool(false)
bool(false)
</pre>

<p>
The logical or operator evaluates to True, if either of the operands is True.
</p>

<pre class="code">
&lt;?php

$a = (True or True);
$b = (True or False);
$c = (False or True);
$d = (False or False);

var_dump($a, $b, $c, $d);

?&gt;
</pre>

<p>
If one of the sides of the operator is True, the outcome of the operation is True. 
</p>

<pre>
$ php orop.php 
bool(true)
bool(true)
bool(true)
bool(false)
</pre>

<p>
The <b>negation</b> operator <code>!</code> makes True False and False True. 
</p>

<pre class="code">
&lt;?php

$a = ! False;
$b = ! True;
$c = ! (4<3);

var_dump($a, $b, $c);

?&gt;
</pre>

<p>
The example shows the negation operator in action.
</p>

<pre>
$ php negation.php 
bool(true)
bool(false)
bool(true)
</pre>

<p>
And, or operators are short circuit evaluated. 
<b>Short circuit evaluation</b> means that the second argument is only evaluated 
if the first argument does not suffice to determine the value of the expression: when the 
first argument of and evaluates to false, the overall value must be false; and when the 
first argument of or evaluates to true, the overall value must be true. (wikipedia)
</p>

<p>
A typical example follows. 
</p>

<pre class="code">
&lt;?php

$x = 10;
$y = 0;

if ($y != 0 and x/y < 100) {
    echo "a small value";
}

?&gt;
</pre>

<p>
The first part of the expression evaluates to False. The second part of the expression is not evaluated. 
Otherwise, we would get a Division by zero error.
</p>

<h2>Relational Operators</h2>

<p>
Relational operators are used to compare values. These operators always result in boolean value. 
</p>

<table>
<tr>
<th>Symbol</th><th>Meaning</th>
</tr>
<tr><td>&lt;</td><td>strictly less than</td></tr>
<tr class="gray"><td>&lt;=</td><td>less than or equal to</td></tr>
<tr><td>&gt;</td><td>greater than</td></tr>
<tr class="gray"><td>&gt;=</td><td>greater than or equal to</td></tr>
<tr><td>==</td><td>equal to</td></tr>
<tr class="gray"><td>!= or &lt;&gt;</td><td>not equal to</td></tr>
<tr><td>===</td><td>identical</td></tr>
<tr class="gray"><td>!==</td><td>not identical</td></tr>
</table>

<pre class="code">
php &gt; var_dump(3 < 4);
bool(true)
php &gt; var_dump(3 == 4);
bool(false)
php &gt; var_dump(4 >= 3);
bool(true)
</pre>

<p>
As we already mentioned, the relational operators return boolean values. 
</p>

<p>
Notice that the relational operators are not limited to numbers. We can 
use them for other objects as well. Although they might not always be meaningful. 
</p>

<pre class="code">
php &gt; var_dump("six" == "six");
bool(true)
php &gt; var_dump("a" > 6);
bool(false)
php &gt; var_dump('a' < 'b');
bool(true)
</pre>

<p>
We can compare string objects too. We can use relational operators for 
different object types. In our case we
compare a string with a number. 
</p>

<pre class="explanation">
php &gt; var_dump('a' < 'b');
</pre>

<p>
What exactly happens here? Computers do not know characters or strings. 
For them, everything is just a number. 
Characters are special numbers stored in specific tables. Like ASCII. 
</p>

<pre class="code">
&lt;?php

echo 'a' &lt; 'b';
echo "\n";

echo 'a is:', ord('a');
echo "\n";
echo 'b is:', ord('b');
echo "\n";

?&gt;
</pre>

<p>
Internally, the a and b characters are numbers. So when we compare two characters, we compare their stored numbers. 
The built-in <code>ord()</code> function returns the ASCII value of a single character. 
</p>

<pre>
$ php compare.php 
1
a is:97
b is:98
</pre>

<p>
In fact, we compare two numbers. 97 with 98. 
</p>

<pre class="code">
php &gt; print "ab" > "aa";
1
</pre>

<p>
Say we have a string with more characters. If the first characters are equal, 
we compare the next ones. In our case, the b character at the second position 
has a greater value than the a character. That is why "ab" string is greater 
than "aa" string. Comparing strings in such a way does not make much sense, 
of course. But it is technically possible.
</p>

<h2>Assignment, equality and identity</h2>

<p>
As you might notice, there are one sign operator (=), two signs operator (==) and three signs (===) operator. 
Now we will talk about the differences among these operators. 
</p>

<p>
The one sign (=) operator is the assignment operator. It loads a value to a variable. 
</p>

<pre class="code">
php > $a = 6;
php > echo $a;
6
</pre>

<p>
In the example, we assign a value 6 to the $a variable. $a now contains number six. We can show
the contents of the $a variable by using the <code>echo</code> command. 
</p>

<p>
The two signs (==) operator is the loose equality operator. It is used to test if the values
in question are equal. Note, that PHP interpreter does some implicit casting when this operator is
used. This leads to some non intuitive results. 
</p>

<pre class="code">
php &gt; var_dump(false == 0);
bool(true)
php &gt; var_dump(false == array());
bool(true)
php &gt; var_dump(true == 1);
bool(true)
php &gt; var_dump(true == "string");
bool(true)
php &gt; var_dump(117 == "000117");
bool(true)
</pre>

<p>
For many programmers, beginners or programmers coming from 
other languages, these results might be surprising. If you compare 
a number with a string or the comparison involves numerical strings,
then each string is converted to a number and the comparison performed numerically.
</p>

<p>
The three sign (===) operator is the strict comparison operator. It is called the identity operator. 
This operator returns true only if the values of the operands are equal and are of the same type. 
</p>

<pre class="code">
php &gt; var_dump(false === 0);
bool(false)
php &gt; var_dump(false === array());
bool(false)
php &gt; var_dump(true === 1);
bool(false)
php &gt; var_dump(true === "string");
bool(false)
php &gt; var_dump(117 === "000117");
bool(false)
</pre>

<p>
As we can see, the identity operator returns the opposite results. 
This operator is more intuitive and
more safe to use.
</p>



<h2>Bitwise operators</h2>

<p>
Decimal numbers are natural to humans. Binary numbers are native to computers. 
Binary, octal, decimal or hexadecimal symbols are only notations of the same number. 
Bitwise operators work with bits of a binary number. We have binary 
logical operators and shift operators. Bitwise operators are seldom used 
in higher level languages like PHP. 
</p>

<table>
<tr>
<th>Symbol</th><th>Meaning</th>
</tr>
<tr><td>~</td><td>bitwise negation</td></tr>
<tr class="gray"><td>^</td><td>bitwise exclusive or</td></tr>
<tr><td>&amp;</td><td>bitwise and</td></tr>
<tr class="gray"><td>|</td><td>bitwise or</td></tr>
<tr><td>&lt;&lt;</td><td>left shift</td></tr>
<tr class="gray"><td>&gt;&gt;</td><td>right shift</td></tr>
</table>

<p>
The <b>bitwise negation operator</b> changes each 1 to 0 and 0 to 1. 
</p>

<pre class="code">
php &gt; print ~7;
-8
php &gt; print ~-8;
7
</pre>

<p>
The operator reverts all bits of a number 7. One of the bits also determines, 
whether the number is negative or not. 
If we negate all the bits one more time, we get number 7 again. 
</p>

<p>
The <b>bitwise and operator</b> performs bit-by-bit comparison between 
two numbers. The result for a bit
position is 1 only if both corresponding bits in the operands are 1. 
</p>

<pre>
     00110
  &amp;  00011
   = 00010
</pre>

<p>
The first number is a binary notation of 6. The second is 3. The result is 2. 
</p>

<pre class="code">
php &gt; print 6 &amp; 3;
2
php &gt; print 3 &amp; 6;
2
</pre>

<p>
The <b>bitwise or operator</b> performs bit-by-bit comparison between two numbers. 
The result for a bit position is 1 if either of the corresponding bits in the operands is 1. 
</p>

<pre>
     00110
  |  00011
   = 00111
</pre>

<p>
The result is <code>00110</code> or decimal 7. 
</p>

<pre class="code">
php &gt; print 6 | 3;
7
</pre>

<p>
The <b>bitwise exclusive or operator</b> performs bit-by-bit comparison between two nubmers. 
The result for a bit position is 1 if one or the other (but not both) of 
the corresponding bits in the operands is 1. 
</p>

<pre>
     00110
  ^  00011
   = 00101
</pre>

<p>
The result is <code>00101</code> or decimal 5. 
</p>

<pre class="code">
php &gt; print 6 ^ 3;
5
</pre>


<p>
Finally, we also have bitwise shift operators. The 
<b>bitwise shift operators</b> shift bits to the right or left. 
</p>

<pre>
number &lt;&lt; n : multiply number 2 to the nth power
number &gt;&gt; n : divide number by 2 to the nth power
</pre>

<p>
These operators are also called arithmetic shift. 
</p>

<pre>
     00110
  >> 00001
   = 00011
</pre>

<p>
We shift each of the bits of number six to the right. It is equal to dividing the six by 2.
The result is <code>00011</code> or decimal 3. 
</p>

<pre class="code">
php &gt; print 6 &gt;&gt; 1;
3
</pre>


<pre>
     00110
  &lt;&lt; 00001
   = 01100
</pre>

<p>
We shift each of the bits of number six to the left. It is equal to multiplying the number six by 2.
The result is <code>01100</code> or decimal 12. 
</p>

<pre class="code">
php &gt; print 6 &lt;&lt; 1;
12
</pre>

<h2>Compound assignment operators</h2>

<p>
The compound assignment operators consist of two operators. 
They are shorthand operators. 
</p>

<pre class="code">
php &gt; $i = 1;
php &gt; $i = $i + 1;
php &gt; print $i;
2
php &gt; $i += 1;
php &gt; print $i;
3
</pre>

<p>
The += compound operator is one of these shorthand operators. 
They are less readable than the full expressions but 
experienced programmers often use them. 
</p>

<p>
Other compound operators are: 
</p>

<pre>
-=   *=   .=   /=    %=   &amp;=   |=   ^=   &gt;&gt;=   &lt;&lt;=   
</pre>



<h2>Operator precedence</h2>

<p>
The <b>operator precedence</b> tells us which operators are 
evaluated first. The precedence level is necessary to avoid
ambiguity in expressions. 
</p>

<p>
What is the outcome of the following expression? 28 or 40?
</p>

<pre>
 3 + 5 * 5
</pre>

<p>
Like in mathematics, the multiplication operator has a higher 
precedence than addition operator. So the outcome is 28.
</p>

<pre>
(3 + 5) * 5
</pre>

<p>
To change the order of evaluation, we can use square brackets. 
Expressions inside square brackets are always evaluated first. 
</p>


<p>
The following list shows common PHP operators ordered by 
precedence (highest precedence first):
</p> 
 
<table> 
  <tr> 
    <th>Operator(s)</th> 
    <th>Description</th> 
  </tr> 
  <tr class="gray"> 
    <td><code>++ --</code></td> 
    <td>increment/decrement</td> 
  </tr> 
  <tr> 
    <td><code>(int) (float) (string) (array) (object) (bool)</code></td> 
    <td>casting</td> 
  </tr> 
  <tr class="gray">
    <td><code>!</code></td> 
    <td>logical "not"</td> 
  </tr> 
  <tr> 
    <td><code>* / %</code></td> 
    <td>arithmetic</td> 
  </tr> 
  <tr class="gray">
    <td><code>+ - .</code></td> 
    <td>arithmetic and string</td> 
  </tr> 
  <tr> 
    <td><code>&lt;&lt; &gt;&gt;</code></td> 
    <td>bitwise</td> 
  </tr> 
  <tr class="gray">
    <td><code>&lt; &lt;= &gt; &gt;= &lt;&gt;</code></td> 
    <td>comparison</td> 
  </tr> 
  <tr> 
    <td><code>== != === !==</code></td> 
    <td>comparison</td> 
  </tr> 
  <tr class="gray">
    <td><code>&amp;&amp;</code></td> 
    <td>logical "and"</td> 
  </tr> 
  <tr>
    <td><code>||</code></td> 
    <td>logical "or"</td> 
  </tr> 
  <tr class="gray">
    <td><code>? :</code></td> 
    <td>ternary operator</td> 
  </tr> 
  <tr>
    <td><code>= += -= *= /= .= %=</code></td> 
    <td>assignment</td> 
  </tr> 
  <tr class="gray">
    <td><code>and</code></td> 
    <td>logical "and"</td> 
  </tr> 
  <tr>
    <td><code>xor</code></td> 
    <td>logical "xor"</td> 
  </tr> 
  <tr class="gray">
    <td><code>or</code></td> 
    <td>logical "or"</td> 
  </tr> 
  <tr>
    <td><code>,</code></td> 
    <td>comma operator</td> 
  </tr> 
</table> 
 
<p>Operators on the same line in the list have the same precedence.
</p> 

<pre class="code">
&lt;?php

print 3 + 5 * 5;
print "\n";
print (3 + 5) * 5;
print "\n";

var_dump(! True or True);
var_dump(! (True or True));

?&gt;
</pre>

<p>
In this code example, we show some common expressions. The outcome of 
each expression is dependent on the precedence level.
</p>


<pre class="explanation">
var_dump(! True or True);
</pre>

<p>
In this case, the negation operator has a higher precedence. 
First, the first True value is negated to False, than the or operator 
combines False and True, which gives True in the end. 
</p>

<pre>
$ php precedence.php 
28
40
bool(true)
bool(false)
</pre>

<p>
The relational operators have a higher precedence than logical operators. 
</p>

<pre class="code">
&lt;?php

$a = 1;
$b = 2;

if ($a > 0 and $b > 0) {

    echo "\$a and \$b are positive integers\n";
}

?&gt;
</pre>

<p>
The and operator awaits two boolean values. If one of the operands 
would not be a boolean value, we would get a
syntax error. In PHP, the relational operators are evaluated first. 
The logical operator then. 
</p>

<pre>
$ php positive.php 
$a and $b are positive integers
</pre>


<h2>Associativity</h2>

<p>
Sometimes the precedence is not satisfactory to determine the outcome 
of an expression. There is another rule called
<b>associativity</b>. The associativity of operators determines the 
order of evaluation of operators with the <b>same</b>
precedence level. 
</p>

<pre>
9 / 3 * 3
</pre>

<p>
What is the outcome of this expression? 9 or 1? The multiplication, deletion and the modulo
operator are left to right associated. So the expression is evaluated 
this way: <code>(9 / 3) * 3</code> and the result is 9.
</p>

<p>
Arithmetic, boolean, relational and bitwise operators are all left to right associated. 
</p>


<p>
On the other hand, the assignment operator is right associated. 
</p>

<pre class="code">
php &gt; $a = $b = $c = $d = 0;
php &gt; echo $a, $b, $c, $d;
0000
</pre>

<p>
If the association was left to right, the previous expression would not be possible. 
</p>

<p>
The compound assignment operators are right to left associated. 
</p>

<pre class="code">
php &gt; $j = 0;
php &gt; $j *= 3 + 1;
php &gt; print $j;
0
</pre>

<p>
You might expect the result to be 1. But the actual result is 0. 
Because of the associativity. The expression on the
right is evaluated first and than the compound assignment operator is applied.
</p>

<h2>Other operators</h2>

<p>
PHP has a <b>silence ( @ ) operator</b>. It is used to turn off 
error messaging. It is typically used with 
network or database connections. This operator should be used 
with caution, because it can lead to 
debugging issues. 
</p>

<pre class="code">
php &gt; echo 3 / 0;

Warning: Division by zero in php shell code on line 1
php &gt; echo @ (3 / 0);
php &gt;
</pre>

<p>
In the first case, we receive a division by zero error message. In the
second case, the @ operator turns off the error message. 
</p>

<p>
The <b>reference ( &amp; ) operator</b>. It creates a reference to an object. 
</p>

<pre class="code">
php &gt; $a = 12;
php &gt; $b = &amp;$a;
php &gt; echo $b;
12
php &gt; $b = 24;
php &gt; echo $b;
24
php &gt; echo $a;
24
</pre>


<p>
In the above example, we pass a value to $a variable and pass a 
reference to the $a to the $b variable. 
</p>

<pre class="explanation">
php &gt; $b = &amp;$a;
</pre>

<p>
We create a new variable $b pointing to the $a variable. In other words,
we create an alias for the $a variable. 
</p>

<pre class="explanation">
php &gt; $b = 24;
php &gt; echo $b;
24
php &gt; echo $a;
24
</pre>

<p>
Assigning a new value to $b will also affect the $a.
</p>

<p>
The <b>backtick ( ` ) operator</b>. It is used to execute commands. It is identical to the
<code>shell_exec()</code> function call. 
</p>

<pre class="explanation">
php &gt; $list = `ls -l`;
php &gt; echo $list;
total 48
-rw-r--r-- 1 vronskij vronskij 127 2009-12-07 11:25 andop.php
-rw-r--r-- 1 vronskij vronskij 174 2009-12-07 10:48 arithmetic.php
-rw-r--r-- 1 vronskij vronskij  86 2010-01-16 15:11 atoperator.php
-rw-r--r-- 1 vronskij vronskij 106 2009-12-07 12:25 compare.php
...
</pre>

<p>
We execute an ls command, which on Unix systems lists the contents of the current directory.
</p>

<p>
In this part of the PHP tutorial, we covered the PHP operators. 
</p>

<div class="center"> 
<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* horizontal */
google_ad_slot = "1734478269";
google_ad_width = 468;
google_ad_height = 60;
//-->
</script> 
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> 
</script> 
</div> 
<br> 


<div class="botNav, center">
<span class="botNavItem"><a href="/">Home</a></span> ‡ <span class="botNavItem"><a href="..">Contents</a></span> ‡ 
<span class="botNavItem"><a href="#">Top of Page</a></span>
</div>


<div class="footer">
<div class="signature">
<a href="/">ZetCode</a> last modified February 20, 2010  <span class="copyright">&copy; 2007 - 2013 Jan Bodnar</span>
</div>
</div>

</div> <!-- content -->

</div> <!-- container -->

</body>
</html>

